home *** CD-ROM | disk | FTP | other *** search
/ Super PC 28 / Super PC 28 (Shareware para Windows 95 y MS-DOS).iso / spc / win / dido3 / source / dido.c next >
Encoding:
C/C++ Source or Header  |  1994-12-15  |  20.2 KB  |  647 lines
  1.  
  2. // don't you leave the...
  3. //
  4. //         D I G I T A L   D O M A I N
  5. //
  6. // lossless digital sound copy from AUDIO CD to WAV files - without crackle & pops!
  7. // No sampling involved. The best quality you can get.
  8. //
  9. // Windows 3.1 freeware by
  10. //                          Michiel Overtoom   (motoom@xs4all.nl)
  11. // Bases on work done by
  12. //                          Yeng-Chee Su       (yenchee@csie.nctu.edu.tw)
  13. // and
  14. //                          Klaas Hemstra      (hst@mh.nl)
  15. //
  16. // and of course... source available.
  17.  
  18. #include <windows.h>
  19. #include <commdlg.h>
  20. #include <dos.h>
  21. #include <stdio.h>
  22. #include <io.h>
  23. #include <stdlib.h>
  24. #include <string.h>
  25. #include <dir.h>
  26. #include <time.h>
  27. #include <mmsystem.h>            // icm mciSendstring
  28. #include "dido.h"                // defines for program resources
  29.  
  30. #define HELPFILE "dido.hlp"
  31.  
  32. HINSTANCE hinst;
  33. WORD    nbuf;                    // number of low memory dos buffers (set by allocating routine)
  34. #define MAXNBUF 20                // Max. number of low mem buffers that can be allocated
  35. int     CDROM;                     // CDROM unit. 0==a, 1==b, etc
  36. int     lowest, highest;        // Lowest and highest track on the CD
  37. int        lineinc=4,pageinc=12;    // skipping factors for scrollbar (in seconds)
  38. DWORD     total_time;                // Total time on CD
  39. char     s[160],t[80],u[80];        // scratch strings
  40. char    waveditor[160]="MPLAYER.EXE";    // editor for WAV files (INI setting)
  41. BOOL     bit16=1,hz44=1,stereo=1;        // settings from recording dialog; options for
  42.                                         // thinning out the recorded sound.
  43.  
  44. #define mb(x) MessageBox(0,x,"Error",0);
  45.  
  46. #include "didod.h"        // low level cd defines/structs
  47. #include "didod.c"        // low level cd routines via DPMI
  48. #include "didologo.c"    // logo routines
  49.  
  50.  
  51. // Set all the controls in a Dialog to the same font
  52. BOOL CALLBACK EnumDialogChild(HWND hw,LPARAM font) {
  53.     SendMessage(hw,WM_SETFONT,(WPARAM)font,0);
  54.        return 1;
  55.     }
  56. void SetDialogFont(HWND dialog,HFONT font)
  57. {
  58.     EnumChildWindows(dialog,EnumDialogChild,(LPARAM)font);
  59. }
  60.  
  61.  
  62. // Center a window
  63. void CenterWindow(HWND hwnd) 
  64. { 
  65.     RECT r; 
  66.     GetWindowRect(hwnd, &r); 
  67.     SetWindowPos(hwnd, NULL,  
  68.        ((GetSystemMetrics(SM_CXSCREEN) - (r.right - r.left)) / 2),  
  69.        ((GetSystemMetrics(SM_CYSCREEN) - (r.bottom - r.top)) / 2),  
  70.        0, 0, SWP_NOSIZE | SWP_NOACTIVATE);  
  71. } 
  72.  
  73. #include "didorec.c"    // recording routine
  74.  
  75.  
  76. // Delay routine, used in initialization
  77. void delay(long ticks)
  78. {
  79.     long expire=clock()+ticks;
  80.     while(clock()<expire);
  81. }
  82.  
  83.  
  84. // Storage for track table
  85. #define MAXTRACK 100        // Have you ever seen a CD with more than 100 tracks?
  86. int   ntrack=0;                // Nr. of tracks on the CD
  87. int   tracknr[MAXTRACK];    // The track number
  88. DWORD trackloc[MAXTRACK];    // Track start in redbook format
  89. DWORD tracklen[MAXTRACK];    // Duration of track, in sectors
  90.  
  91.  
  92. // Build a table of tracks
  93. int BuildTrackTable(void)
  94. {
  95.     int i;
  96.     DWORD loc;
  97.     // Scan the tracks
  98.     ntrack=0;
  99.     for (i=lowest;i<=highest;i++) {
  100.         if (!GetTrackInfo(i,&loc)) return 0;
  101.         tracknr[ntrack]=i;
  102.         trackloc[ntrack]=loc;
  103.         ntrack++;
  104.         }
  105.     // Calculate the durations
  106.     trackloc[ntrack]=total_time;
  107.     for (i=0;i<ntrack;i++) tracklen[i]=Red2Sierra(trackloc[i+1])-Red2Sierra(trackloc[i]);
  108.     return 1;
  109. }
  110.  
  111.  
  112. // Ask for a WAV file
  113. int ChooseWavFile(HWND hwnd,char *fn)
  114. {
  115.     OPENFILENAME ofn;
  116.     char szFile[128]={0};
  117.     char szFileTitle[128]={0};
  118.     // File uitkiezen
  119.     memset(&ofn, 0, sizeof(ofn));
  120.     strcpy(szFile,fn);
  121.     strcpy(szFileTitle,fn);
  122.     ofn.lStructSize = sizeof(ofn);
  123.     ofn.hwndOwner = hwnd;
  124.     ofn.lpstrFilter = "Wave audio (*.wav)\0*.wav\0";
  125.     ofn.nFilterIndex = 1;
  126.     ofn.lpstrFile= szFile;
  127.     ofn.nMaxFile = 128;
  128.     ofn.lpstrFileTitle= szFileTitle;
  129.     ofn.nMaxFileTitle = 128;
  130.     ofn.Flags = OFN_PATHMUSTEXIST|OFN_HIDEREADONLY;
  131.     if (!GetSaveFileName(&ofn)) return 0;
  132.     strcpy(fn,ofn.lpstrFile);
  133.     return 1;
  134. }
  135.  
  136.  
  137. // Get-a-value dialog proc
  138. struct values {
  139.     DWORD    val;
  140.     DWORD     from;
  141.     DWORD    to; 
  142.     };
  143. #pragma argsused
  144. BOOL CALLBACK ValueDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  145. {
  146.     char s[20];
  147.     static struct values *value; 
  148.     if (msg==WM_INITDIALOG) {
  149.         value=(struct values *)lp;
  150.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  151.            sprintf(s,"%ld",value->val);
  152.         SetDlgItemText(hdlg,VALUE,s);
  153.         }
  154.     if (msg==WM_COMMAND && wp==IDOK) {
  155.         GetDlgItemText(hdlg,VALUE,s,19);
  156.         value->val=atol(s);
  157.         if (value->val < value->from)
  158.             value->val=value->from;
  159.         else if (value->val > value->to)
  160.             value->val=value->to;
  161.         EndDialog(hdlg,1);
  162.         }
  163.     return 0;
  164. }
  165.  
  166.  
  167. // Wrapper for get-a-value dialog. Provides default, ranges, etc...
  168. DWORD GetValue(HWND caller,DWORD defalt,DWORD from,DWORD to)
  169. {
  170.     struct values value;
  171.     value.from=from; value.to=to; value.val=defalt;
  172.     DialogBoxParam(hinst,"ValueDlg",caller,ValueDlgProc,(LPARAM)&value);
  173.     return value.val;
  174. }
  175.  
  176.  
  177. // Record dialog
  178. #pragma argsused
  179. BOOL CALLBACK RecDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  180. {
  181.     static int restartsound=0,autorewind=1,autorepeat=1;
  182.     static int refresh=0;
  183.     static int tnr;                    // track number
  184.     static DWORD start,end;            // Start/ending recording position, redbook format
  185.     static WORD  sm,ss,sf;            // Start recording position: minute, second, frame
  186.     static WORD  em,es,ef;            // idem, End position
  187.     static DWORD sc,ec;                // Start/ending recording sectors
  188.     static char fn[80];                // Last used filename
  189.     DWORD dur;
  190.     WORD  div;
  191.  
  192.     if (msg==WM_INITDIALOG) {
  193.         // Initialize record dialog
  194.         fn[0]=0;                                              // Zap filename
  195.         tnr=(WORD)lp;                                        // Remember track number
  196.         sprintf(s,"Search (track %d)",tracknr[tnr]);        // put it also in the
  197.         SetWindowText(hdlg,s);                                // dialog title
  198.         CenterWindow(hdlg);
  199.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  200.         // Fill inputs with track defaults
  201.         Red2MSFC(start=trackloc[tnr],&sm,&ss,&sf,&sc);
  202.         Red2MSFC(end=trackloc[tnr+1],&em,&es,&ef,&ec);
  203.         // Set scroll bar extents en posities
  204.         SetScrollRange(GetDlgItem(hdlg,SBAR),SB_CTL,0,Red2Sierra(total_time)/75L,0);
  205.         SetScrollRange(GetDlgItem(hdlg,EBAR),SB_CTL,0,Red2Sierra(total_time)/75L,0);
  206.         SetScrollPos(GetDlgItem(hdlg,SBAR),SB_CTL,Red2Sierra(start)/75L,0);
  207.         SetScrollPos(GetDlgItem(hdlg,EBAR),SB_CTL,Red2Sierra(end)/75L,0);
  208.         // Assure all fields will be refreshed; also start playing the track
  209.         refresh=1;
  210.         restartsound=1;
  211.         }
  212.  
  213.     // Button pressed!
  214.     #define FRESH refresh=1; if (autorewind) restartsound=1
  215.     if (msg==WM_COMMAND) {
  216.         if (wp==LISTEN) restartsound=1;
  217.         if (wp==IDOK) {StopAudio(); EndDialog(hdlg,1);}
  218.         if (wp==STEREO) {stereo=1; refresh=1;}
  219.         if (wp==MONO) {stereo=0; refresh=1;}
  220.         if (wp==HZ44) {hz44=1; refresh=1;}
  221.         if (wp==HZ22) {hz44=0; refresh=1;}
  222.         if (wp==BIT16) {bit16=1; refresh=1;}
  223.         if (wp==BIT8) {bit16=0; refresh=1;}
  224.         if (wp==RECORD) {
  225.             StopAudio(); PlayAudio(start,10);            // This prevents sync errors (? beats me but it does!)
  226.             EnableWindow(hdlg,0);                        
  227.             sprintf(fn,"%d-%d-%d.wav",sm,ss,sf);        // Compose a filename using start time
  228.             if (ChooseWavFile(hdlg,fn)) {                // File selection box
  229.                 dur=Red2Sierra(end)-Red2Sierra(start);
  230.                 if (!record(fn,Red2Sierra(start),dur)) mb(error);    // record it.
  231.                 FRESH;
  232.                 }
  233.             EnableWindow(hdlg,1);
  234.             }
  235.         if (wp==EDIT) {
  236.             if (access(fn,0)==0) {                        // Edit only allowed when last used
  237.                 sprintf(s,"%s %s",waveditor,fn);        // is present, and if the file exist.
  238.                 StopAudio();
  239.                 if (WinExec(s,SW_SHOWNORMAL)<32)        // Spawn the WAV editor
  240.                     MessageBox(hdlg,s,"cant execute editor",MB_OK);
  241.                 }
  242.             }
  243.         if (wp==AUTOREWIND) {autorewind=1-autorewind; refresh=1;}
  244.         if (wp==AUTOREPEAT) {autorepeat=1-autorepeat; refresh=1;}
  245.         // Adjusting start time...
  246.         if (wp==SM) {
  247.             sm=GetValue(hdlg,sm,0,99);
  248.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  249.             }
  250.         if (wp==SMDOWN) {
  251.             if (sm) sm--;
  252.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  253.             }
  254.         if (wp==SMUP)   {
  255.             sm++;
  256.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  257.             }
  258.         if (wp==SS) {
  259.             ss=GetValue(hdlg,ss,0,59);
  260.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  261.             }
  262.         if (wp==SSDOWN) {
  263.             if (ss) ss--;
  264.             else if (sm) {sm--; ss=59;}
  265.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  266.             }
  267.         if (wp==SSUP)   {
  268.             ss++;
  269.             if (ss>59) {ss=0; sm++;}
  270.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  271.             }
  272.         if (wp==SF) {
  273.             sf=GetValue(hdlg,sf,0,74);
  274.             MSF2Red(sm,ss,sf,&start,&sc);    FRESH;
  275.             }
  276.         if ((wp==SFDOWN)||(wp==SCDOWN)) {
  277.             if (sf) {
  278.                 sf--;
  279.                 }
  280.             else if (ss) {
  281.                 ss--; sf=74;
  282.                 }
  283.             else if (sm) {
  284.                 sm--; ss=59; sf=74;
  285.                 }
  286.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  287.             }
  288.         if ((wp==SFUP)||(wp==SCUP))   {
  289.             sf++;
  290.             if (sf>74) {
  291.                 sf=0; ss++;
  292.                 if (ss>59) {
  293.                     sm++; ss=0;
  294.                     }
  295.                 }
  296.             MSF2Red(sm,ss,sf,&start,&sc);   FRESH;
  297.             }
  298.         // Adjusting end time...
  299.         if (wp==EM) {
  300.             em=GetValue(hdlg,em,0,99);
  301.             MSF2Red(em,es,ef,&end,&ec);    FRESH;
  302.             }
  303.         if (wp==EMDOWN) {
  304.             if (em) em--;
  305.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  306.             }
  307.         if (wp==EMUP)   {
  308.             em++;
  309.             MSF2Red(em,es,ef,&end,&ec);       FRESH;
  310.             }
  311.         if (wp==ES) {
  312.             es=GetValue(hdlg,es,0,59);
  313.             MSF2Red(em,es,ef,&end,&ec);    FRESH;
  314.             }
  315.         if (wp==ESDOWN) {
  316.             if (es) es--;
  317.             else if (em) {em--; es=59;}
  318.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  319.             }
  320.         if (wp==ESUP)   {
  321.             es++;
  322.             if (es>59) {es=0; em++;}
  323.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  324.             }
  325.         if (wp==EF) {
  326.             ef=GetValue(hdlg,ef,0,74);
  327.             MSF2Red(em,es,ef,&end,&ec);    FRESH;
  328.             }
  329.         if ((wp==EFDOWN)||(wp==ECDOWN)) {
  330.             if (ef) {
  331.                 ef--;
  332.                 }
  333.             else if (es) {
  334.                 es--; ef=74;
  335.                 }
  336.             else if (em) {
  337.                 em--; es=59; ef=74;
  338.                 }
  339.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  340.             }
  341.         if ((wp==EFUP)||(wp==ECUP))   {
  342.             ef++;
  343.             if (ef>74) {
  344.                 ef=0; es++;
  345.                 if (es>59) {
  346.                     em++; es=0;
  347.                     }
  348.                 }
  349.             MSF2Red(em,es,ef,&end,&ec);        FRESH;
  350.             }
  351.         }
  352.  
  353.     // Scroll bar?
  354.     if (msg==WM_HSCROLL) { // SBAR, EBAR
  355.         BOOL isstart=0;
  356.         int sc=wp;                // Scrollcode
  357.         int pos=LOWORD(lp);        // position
  358.         if (GetDlgItem(hdlg,SBAR)==(HWND)HIWORD(lp)) isstart=1;
  359.         if (sc==SB_THUMBPOSITION || sc==SB_THUMBTRACK) {
  360.             if (isstart) 
  361.                 Red2MSFC(start=Sierra2Red(75L*pos),&sm,&ss,&sf,&sc);
  362.             else 
  363.                 Red2MSFC(end=Sierra2Red(75L*pos),&em,&es,&ef,&ec);
  364.             FRESH;
  365.             }
  366.         if (sc==SB_LINEUP) {
  367.             if (isstart) {
  368.                 long newstart=Red2Sierra(start)-75L*lineinc;
  369.                 if (newstart<0) newstart=0;
  370.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  371.                 }
  372.             else {
  373.                 long newend=Red2Sierra(end)-75L*lineinc;
  374.                 if (newend<0) newend=0;
  375.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  376.                 }
  377.             FRESH;
  378.             }
  379.         if (sc==SB_LINEDOWN) {
  380.             if (isstart) {
  381.                 long newstart=Red2Sierra(start)+75L*lineinc;
  382.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  383.                 }
  384.             else {
  385.                 long newend=Red2Sierra(end)+75L*lineinc;
  386.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  387.                 }
  388.             FRESH;
  389.             }
  390.         if (sc==SB_PAGEUP) {
  391.             if (isstart) {
  392.                 long newstart=Red2Sierra(start)-75L*pageinc;
  393.                 if (newstart<0) newstart=0;
  394.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  395.                 }
  396.             else {
  397.                 long newend=Red2Sierra(end)-75L*pageinc;
  398.                 if (newend<0) newend=0;
  399.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  400.                 }
  401.             FRESH;
  402.             }
  403.         if (sc==SB_PAGEDOWN) {
  404.             if (isstart) {
  405.                 long newstart=Red2Sierra(start)+75L*pageinc;
  406.                 Red2MSFC(start=Sierra2Red(newstart),&sm,&ss,&sf,&sc);
  407.                 }
  408.             else {
  409.                 long newend=Red2Sierra(end)+75L*pageinc;
  410.                 Red2MSFC(end=Sierra2Red(newend),&em,&es,&ef,&ec);
  411.                 }
  412.             FRESH;
  413.             }
  414.         }
  415.  
  416.  
  417.     // Something needs redrawing? Well, redraw them all.
  418.     if (refresh) {
  419.         refresh=0;
  420.         // Never play outside CD tracks - may hang the driver
  421.         if (start<trackloc[0])         Red2MSFC(start=trackloc[0],&sm,&ss,&sf,&sc);
  422.         if (start>trackloc[ntrack]) Red2MSFC(start=trackloc[ntrack],&sm,&ss,&sf,&sc);
  423.         if (end<trackloc[0])         Red2MSFC(end=trackloc[0],&em,&es,&ef,&ec);
  424.         if (end>trackloc[ntrack])     Red2MSFC(end=trackloc[ntrack],&em,&es,&ef,&ec);
  425.         if (start>end)                 Red2MSFC(end=start,&em,&es,&ef,&ec);
  426.         // Update the numerals in the edit controls
  427.         Red2MSFC(start,&sm,&ss,&sf,&sc);
  428.         Red2MSFC(end,&em,&es,&ef,&ec);
  429.  
  430.         SetDlgItemInt(hdlg,SM,sm,0);    SetDlgItemInt(hdlg,SS,ss,0);
  431.         SetDlgItemInt(hdlg,SF,sf,0);
  432.         sprintf(s,"%lu",sc); SetDlgItemText(hdlg,SC,s);
  433.  
  434.         SetDlgItemInt(hdlg,EM,em,0);    SetDlgItemInt(hdlg,ES,es,0);
  435.         SetDlgItemInt(hdlg,EF,ef,0);
  436.         sprintf(s,"%lu",ec); SetDlgItemText(hdlg,EC,s);
  437.         // Update scroll bars
  438.         SetScrollPos(GetDlgItem(hdlg,SBAR),SB_CTL,Red2Sierra(start)/75L,1);
  439.         SetScrollPos(GetDlgItem(hdlg,EBAR),SB_CTL,Red2Sierra(end)/75L,1);
  440.  
  441.         // Set radiobuttons
  442.         if (!bit16) {
  443.             hz44=0; stereo=0;
  444.             EnableWindow(GetDlgItem(hdlg,HZ22),0);
  445.             EnableWindow(GetDlgItem(hdlg,HZ44),0);
  446.             EnableWindow(GetDlgItem(hdlg,MONO),0);
  447.             EnableWindow(GetDlgItem(hdlg,STEREO),0);
  448.             }
  449.         else {
  450.             EnableWindow(GetDlgItem(hdlg,HZ22),1);
  451.             EnableWindow(GetDlgItem(hdlg,HZ44),1);
  452.             EnableWindow(GetDlgItem(hdlg,MONO),1);
  453.             EnableWindow(GetDlgItem(hdlg,STEREO),1);
  454.             }
  455.         CheckRadioButton(hdlg,MONO,STEREO,stereo?STEREO:MONO);
  456.         CheckRadioButton(hdlg,HZ22,HZ44,hz44?HZ44:HZ22);
  457.         CheckRadioButton(hdlg,BIT8,BIT16,bit16?BIT16:BIT8);
  458.         CheckDlgButton(hdlg,AUTOREWIND,autorewind);
  459.         CheckDlgButton(hdlg,AUTOREPEAT,autorepeat);
  460.         if (*fn && access(fn,0)==0)
  461.             EnableWindow(GetDlgItem(hdlg,EDIT),1);
  462.         else
  463.             EnableWindow(GetDlgItem(hdlg,EDIT),0);
  464.         // Calculate projected file size and duration
  465.         dur=Red2Sierra(end)-Red2Sierra(start);
  466.         div=0; if (!stereo) div++; if (!hz44) div++; if (!bit16) div++;
  467.         sprintf(s,"%ld Kbytes",((dur*2352)>>div)/1024);
  468.         SetDlgItemText(hdlg,FSIZE,s);
  469.         sprintf(s,"%s   /  %ld sectors",Sector2MSF(dur),dur);
  470.         SetDlgItemText(hdlg,DUR,s);
  471.         }
  472.  
  473.     // Issue a play command to the CD player
  474.     if (restartsound) {
  475.         restartsound=0;
  476.         StopAudio();
  477.         PlayAudio(start,Red2Sierra(end)-Red2Sierra(start));
  478.         }
  479.     return 0;
  480. }
  481.  
  482.  
  483. // Preferences dialog proc
  484. #pragma argsused
  485. BOOL CALLBACK PrefDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  486. {
  487.     if (msg==WM_INITDIALOG) {
  488.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  489.         sprintf(s,"%d audio buffers allocated",nbuf);
  490.         SetDlgItemText(hdlg,BUFRESULT,s);
  491.         SetDlgItemText(hdlg,WAVEDITOR,waveditor);
  492.         }
  493.     if (msg==WM_COMMAND && wp==IDOK) {
  494.         GetDlgItemText(hdlg,WAVEDITOR,waveditor,159);
  495.         WriteProfileString("Digital Domain","WAVeditor",waveditor);
  496.         EndDialog(hdlg,1);
  497.         }
  498.     return 0;
  499. }
  500.  
  501. // Sync error dialog proc
  502. #pragma argsused
  503. BOOL CALLBACK SyncErrDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  504. {
  505.     if (msg==WM_INITDIALOG) SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  506.     if (msg==WM_COMMAND) {
  507.         if (wp==ABOUT) {
  508.             WinHelp(hdlg,HELPFILE,HELP_KEY,"SyncErr");
  509.             EndDialog(hdlg,1);
  510.             }
  511.         if (wp==IDCANCEL) {
  512.             EndDialog(hdlg,1);
  513.             }
  514.         }
  515.     return 0;
  516. }
  517.  
  518. // Memalloc error dialog proc
  519. #pragma argsused
  520. BOOL CALLBACK MemErrDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  521. {
  522.     if (msg==WM_INITDIALOG) SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  523.     if (msg==WM_COMMAND) {
  524.         if (wp==ABOUT) {
  525.             WinHelp(hdlg,HELPFILE,HELP_KEY,"MemErr");
  526.             EndDialog(hdlg,1);
  527.             }
  528.         if (wp==IDCANCEL) {
  529.             EndDialog(hdlg,1);
  530.             }
  531.         }
  532.     return 0;
  533. }
  534.  
  535. // Main dialog proc
  536. #pragma argsused
  537. BOOL CALLBACK MainDlgProc(HWND hdlg, UINT msg, WPARAM wp, LPARAM lp)
  538. {
  539.     int i;
  540.     if (msg==WM_INITDIALOG) {
  541.         SetDialogFont(hdlg,GetStockObject(ANSI_VAR_FONT));
  542.         // Infoheaderts at top 
  543.         SetDlgItemText(hdlg,PLAYINGTIME,Sector2MSF(Red2Sierra(total_time)));
  544.         sprintf(s,"%d",highest-lowest+1);
  545.         SetDlgItemText(hdlg,NRTRACKS,s);
  546.         // Track table
  547.         if (!BuildTrackTable()) mb("Error building the track table");
  548.         SendDlgItemMessage(hdlg,TRACKLIST,LB_RESETCONTENT,0,0);
  549.         for (i=0;i<ntrack;i++) {
  550.             strcpy(t,Red2MSF(trackloc[i]));
  551.             sprintf(s," %2d.   %s     start at %s    %ld sectors",
  552.                         tracknr[i],
  553.                         Sector2MSF(tracklen[i]),
  554.                         Red2MSF(trackloc[i]),
  555.                         tracklen[i]
  556.                         );
  557.             SendDlgItemMessage(hdlg,TRACKLIST,LB_ADDSTRING,0,(LPARAM)s);
  558.             }
  559.         }
  560.     // Some button or track line clicked?
  561.     if (msg==WM_COMMAND) {
  562.         if (HIWORD(lp)==LBN_SELCHANGE) {
  563.             int item;
  564.             if (hlogo) ToggleLogo();
  565.             item=(WORD)SendDlgItemMessage(hdlg,TRACKLIST,LB_GETCURSEL,0,0L);
  566.             if (item!=LB_ERR) {
  567.                 EnableWindow(hdlg,0);
  568.                 if (-1==DialogBoxParam(hinst,"RecDlg",0,RecDlgProc,item))
  569.                     mb("cant create record dialog");
  570.                 EnableWindow(hdlg,1); SetFocus(GetDlgItem(hdlg,TRACKLIST));
  571.                 }
  572.             }
  573.         else {
  574.             if (wp==PREFS) {
  575.                 EnableWindow(hdlg,0);
  576.                 DialogBox(hinst,"PrefDlg",0,PrefDlgProc);
  577.                 EnableWindow(hdlg,1); SetFocus(GetDlgItem(hdlg,TRACKLIST));
  578.                 }
  579.             if (wp==QUIT || wp==EJECT) {StopAudio(); EndDialog(hdlg,wp);}
  580.             if (wp==ABOUT) WinHelp(GetDesktopWindow(),HELPFILE,HELP_CONTENTS,0);
  581.             }
  582.         }
  583.     return 0;
  584. }
  585.  
  586.  
  587. // Mainprogram entry point
  588. #pragma argsused
  589. int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,LPSTR lpszCmdLine, int cmdShow)
  590. {
  591.     MSG msg;
  592.     int try,status,result;
  593.     hinst=hInstance;
  594.  
  595.     // Allocate buffers in low memory
  596.     if (!startinterfacing()) {
  597.         DialogBox(hInstance,"MemErrDlg",0,MemErrDlgProc);
  598.         return 0;
  599.         }
  600.     // Is MSCDEX installed? If not, abort.
  601.     if (!CheckMscdex()) {
  602.         mb("MSCDEX not installed");
  603.         return 0;
  604.         }
  605.     // Display logo
  606.     RegisterLogo(hinst);
  607.     ToggleLogo();
  608.     // Give some time slices so the logo will display
  609.     while (PeekMessage(&msg,0,0,0,PM_REMOVE)) {
  610.         TranslateMessage(&msg);
  611.            DispatchMessage(&msg);
  612.         }
  613.     // Wait a bit
  614.     delay(CLK_TCK*2);
  615. Rescan:
  616.     // Get global information about CD
  617.     status=GetDiskInfo(); try=0;
  618.     while (status!=0x0100) {
  619.         delay(CLK_TCK);
  620.         if (++try>=3) {
  621.             if (MessageBox(0,"Insert an audio CD in the drive","CDROM is busy",MB_RETRYCANCEL)==IDCANCEL) {
  622.                 // ieks... terminate
  623.                 stopinterfacing();
  624.                 return 0;
  625.                 }
  626.             try=0;
  627.             }
  628.         status=GetDiskInfo();
  629.         }
  630.     // Do the interaction
  631.     GetProfileString("Digital Domain","WAVeditor",waveditor,waveditor,159);
  632.     result=DialogBox(hinst,"MainDlg",0,MainDlgProc);
  633.     if (result==EJECT) {
  634.         // Try MCI, for a change
  635.         mciSendString("SET CDAUDIO DOOR OPEN", NULL, 0, NULL ); // This one works OK on my drive...
  636.         MessageBox(0,"You can change the CD now","Digital Domain",MB_OK);
  637.         mciSendString("SET CDAUDIO DOOR CLOSED", NULL, 0, NULL ); // This does NOT work on my drive...
  638.         delay(6*CLK_TCK);
  639.         goto Rescan;
  640.         }
  641.     WinHelp(GetDesktopWindow(),HELPFILE,HELP_QUIT,0);
  642.     // Free up
  643.     stopinterfacing();
  644.     if (hlogo) ToggleLogo();
  645.     return 0;
  646. }
  647.